home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / utils / ObjectProxy.as < prev    next >
Text File  |  2014-03-27  |  8KB  |  265 lines
  1. package mx.utils
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.IDataInput;
  6.    import flash.utils.IDataOutput;
  7.    import flash.utils.IExternalizable;
  8.    import flash.utils.Proxy;
  9.    import flash.utils.flash_proxy;
  10.    import flash.utils.getQualifiedClassName;
  11.    import mx.core.IPropertyChangeNotifier;
  12.    import mx.events.PropertyChangeEvent;
  13.    import mx.events.PropertyChangeEventKind;
  14.    
  15.    use namespace object_proxy;
  16.    use namespace flash_proxy;
  17.    
  18.    [Bindable("propertyChange")]
  19.    public dynamic class ObjectProxy extends Proxy implements IExternalizable, IPropertyChangeNotifier
  20.    {
  21.        
  22.       
  23.       private var _id:String;
  24.       
  25.       protected var notifiers:Object;
  26.       
  27.       protected var propertyList:Array;
  28.       
  29.       private var _proxyLevel:int;
  30.       
  31.       private var _type:QName;
  32.       
  33.       protected var dispatcher:EventDispatcher;
  34.       
  35.       protected var proxyClass:Class;
  36.       
  37.       private var _item:Object;
  38.       
  39.       public function ObjectProxy(param1:Object = null, param2:String = null, param3:int = -1)
  40.       {
  41.          proxyClass = ObjectProxy;
  42.          super();
  43.          if(!param1)
  44.          {
  45.             param1 = {};
  46.          }
  47.          _item = param1;
  48.          _proxyLevel = param3;
  49.          notifiers = {};
  50.          dispatcher = new EventDispatcher(this);
  51.          if(param2)
  52.          {
  53.             _id = param2;
  54.          }
  55.       }
  56.       
  57.       public function dispatchEvent(param1:Event) : Boolean
  58.       {
  59.          return dispatcher.dispatchEvent(param1);
  60.       }
  61.       
  62.       public function hasEventListener(param1:String) : Boolean
  63.       {
  64.          return dispatcher.hasEventListener(param1);
  65.       }
  66.       
  67.       override flash_proxy function setProperty(param1:*, param2:*) : void
  68.       {
  69.          var _loc4_:IPropertyChangeNotifier = null;
  70.          var _loc5_:PropertyChangeEvent = null;
  71.          var _loc3_:* = _item[param1];
  72.          if(_loc3_ !== param2)
  73.          {
  74.             _item[param1] = param2;
  75.             if(_loc4_ = IPropertyChangeNotifier(notifiers[param1]))
  76.             {
  77.                _loc4_.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,propertyChangeHandler);
  78.                delete notifiers[param1];
  79.             }
  80.             if(dispatcher.hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE))
  81.             {
  82.                if(param1 is QName)
  83.                {
  84.                   param1 = QName(param1).localName;
  85.                }
  86.                _loc5_ = PropertyChangeEvent.createUpdateEvent(this,param1.toString(),_loc3_,param2);
  87.                dispatcher.dispatchEvent(_loc5_);
  88.             }
  89.          }
  90.       }
  91.       
  92.       public function willTrigger(param1:String) : Boolean
  93.       {
  94.          return dispatcher.willTrigger(param1);
  95.       }
  96.       
  97.       public function readExternal(param1:IDataInput) : void
  98.       {
  99.          var _loc2_:Object = param1.readObject();
  100.          _item = _loc2_;
  101.       }
  102.       
  103.       public function writeExternal(param1:IDataOutput) : void
  104.       {
  105.          param1.writeObject(_item);
  106.       }
  107.       
  108.       override flash_proxy function getProperty(param1:*) : *
  109.       {
  110.          var _loc2_:* = undefined;
  111.          if(notifiers[param1.toString()])
  112.          {
  113.             return notifiers[param1];
  114.          }
  115.          _loc2_ = _item[param1];
  116.          if(_loc2_)
  117.          {
  118.             if(_proxyLevel == 0 || ObjectUtil.isSimple(_loc2_))
  119.             {
  120.                return _loc2_;
  121.             }
  122.             _loc2_ = getComplexProperty(param1,_loc2_);
  123.          }
  124.          return _loc2_;
  125.       }
  126.       
  127.       override flash_proxy function hasProperty(param1:*) : Boolean
  128.       {
  129.          return param1 in _item;
  130.       }
  131.       
  132.       public function get uid() : String
  133.       {
  134.          if(_id === null)
  135.          {
  136.             _id = UIDUtil.createUID();
  137.          }
  138.          return _id;
  139.       }
  140.       
  141.       override flash_proxy function nextNameIndex(param1:int) : int
  142.       {
  143.          if(param1 == 0)
  144.          {
  145.             setupPropertyList();
  146.          }
  147.          if(param1 < propertyList.length)
  148.          {
  149.             return param1 + 1;
  150.          }
  151.          return 0;
  152.       }
  153.       
  154.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  155.       {
  156.          dispatcher.addEventListener(param1,param2,param3,param4,param5);
  157.       }
  158.       
  159.       override flash_proxy function nextName(param1:int) : String
  160.       {
  161.          return propertyList[param1 - 1];
  162.       }
  163.       
  164.       public function set uid(param1:String) : void
  165.       {
  166.          _id = param1;
  167.       }
  168.       
  169.       override flash_proxy function callProperty(param1:*, ... rest) : *
  170.       {
  171.          return _item[param1].apply(_item,rest);
  172.       }
  173.       
  174.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  175.       {
  176.          dispatcher.removeEventListener(param1,param2,param3);
  177.       }
  178.       
  179.       protected function setupPropertyList() : void
  180.       {
  181.          var _loc1_:* = null;
  182.          if(getQualifiedClassName(_item) == "Object")
  183.          {
  184.             propertyList = [];
  185.             for(_loc1_ in _item)
  186.             {
  187.                propertyList.push(_loc1_);
  188.             }
  189.          }
  190.          else
  191.          {
  192.             propertyList = ObjectUtil.getClassInfo(_item,null,{
  193.                "includeReadOnly":true,
  194.                "uris":["*"]
  195.             }).properties;
  196.          }
  197.       }
  198.       
  199.       object_proxy function getComplexProperty(param1:*, param2:*) : *
  200.       {
  201.          if(param2 is IPropertyChangeNotifier)
  202.          {
  203.             param2.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,propertyChangeHandler);
  204.             notifiers[param1] = param2;
  205.             return param2;
  206.          }
  207.          if(getQualifiedClassName(param2) == "Object")
  208.          {
  209.             param2 = new proxyClass(_item[param1],null,_proxyLevel > 0 ? _proxyLevel - 1 : _proxyLevel);
  210.             param2.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,propertyChangeHandler);
  211.             notifiers[param1] = param2;
  212.             return param2;
  213.          }
  214.          return param2;
  215.       }
  216.       
  217.       override flash_proxy function deleteProperty(param1:*) : Boolean
  218.       {
  219.          var _loc5_:PropertyChangeEvent = null;
  220.          var _loc2_:IPropertyChangeNotifier = IPropertyChangeNotifier(notifiers[param1]);
  221.          if(_loc2_)
  222.          {
  223.             _loc2_.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,propertyChangeHandler);
  224.             delete notifiers[param1];
  225.          }
  226.          var _loc3_:* = _item[param1];
  227.          var _loc4_:* = delete _item[param1];
  228.          if(dispatcher.hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE))
  229.          {
  230.             (_loc5_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE)).kind = PropertyChangeEventKind.DELETE;
  231.             _loc5_.property = param1;
  232.             _loc5_.oldValue = _loc3_;
  233.             _loc5_.source = this;
  234.             dispatcher.dispatchEvent(_loc5_);
  235.          }
  236.          return _loc4_;
  237.       }
  238.       
  239.       object_proxy function get type() : QName
  240.       {
  241.          return _type;
  242.       }
  243.       
  244.       object_proxy function set type(param1:QName) : void
  245.       {
  246.          _type = param1;
  247.       }
  248.       
  249.       public function propertyChangeHandler(param1:PropertyChangeEvent) : void
  250.       {
  251.          dispatcher.dispatchEvent(param1);
  252.       }
  253.       
  254.       override flash_proxy function nextValue(param1:int) : *
  255.       {
  256.          return _item[propertyList[param1 - 1]];
  257.       }
  258.       
  259.       object_proxy function get object() : Object
  260.       {
  261.          return _item;
  262.       }
  263.    }
  264. }
  265.